Performance

How fast kanbo answers on boards of 100, 1,000 and 10,000 cards, how many database statements each read costs, and how much text each MCP tool hands an agent. Numbers below were taken on 2026-09-28 with scripts/bench.mjs, before and after agent efficiency. Real agents is what Claude Code and Codex actually do with the board, from evals/agent-eval.mjs.

Method#

  • Machine: Apple M1 Pro (10 cores), 32 GB, macOS 14.4 (Darwin 23.4.0), Node 24.13.0.
  • Boards: a SQLite board file in a temporary folder, and a Postgres board in PGlite — real Postgres compiled to WebAssembly, running in the bench process. PGlite has no network hop, so a real server adds one round trip per statement on top of these times (see statements).
  • Data: seeded through kanbo's own operations, so every row is one a real board carries. Out of every 20 cards: 4 in Backlog, 6 in To Do, 3 in In Progress (each with a running agent run and a status line), 2 in In Review (waiting for a person), 5 in Done (each with a finished run). Every card has a ~250-character description and two comments; a third of the cards have a label.
  • Timing: 20 samples per operation after one warm-up (5 for a spawned CLI); p50 / p95 in milliseconds. Writes (create, move) add cards or move them between To Do and In Progress while they are measured.
  • Surfaces:
    • ops — the board operations a host app calls (createBoardOps).
    • cli (in-process) — the kanbo command, run in the bench process: what a command costs without Node starting up. Opens the board each time, as a command does.
    • cli (spawned) — node dist/cli.cjs … --json as a shell or an agent's Bash tool runs it, Node start-up included (SQLite only: a spawned process cannot reach an in-process PGlite).
    • mcp — the MCP tools through an MCP client on an in-memory pipe.
    • serve — GET /issues on kanbo serve, over HTTP on loopback.

Results#

p50 / p95 in ms. "statements" is what one call ran — the same at every size. Numbers are after agent efficiency (list and ready answer a page of compact cards and filter in the database); the numbers before it are in Before and after.

SQLite (board file)#

surfaceoperation100 cards1,000 cards10,000 cardsstatements
opscreate card0.53 / 0.630.61 / 0.961.31 / 1.5010
opsmove card0.77 / 0.910.76 / 0.960.77 / 0.8615
opslist cards0.91 / 0.946.42 / 7.0269.6 / 73.52
opsready0.41 / 0.481.78 / 1.9616.7 / 18.52
opsprime0.06 / 0.080.06 / 0.090.06 / 0.081
opscard get + comments0.40 / 0.440.46 / 0.760.43 / 0.545
cli (in-process)card list1.89 / 2.472.81 / 3.3213.6 / 15.24
cli (in-process)card list --column in_progress1.36 / 1.461.87 / 2.374.29 / 5.134
cli (in-process)ready1.15 / 1.211.67 / 2.066.43 / 7.054
cli (in-process)prime0.71 / 1.010.74 / 0.870.73 / 0.802
cli (in-process)card get1.47 / 1.791.36 / 1.521.37 / 1.807
cli (in-process)board1.94 / 2.708.71 / 9.5984.5 / 89.94
mcpkanbo_prime0.12 / 0.190.08 / 0.090.13 / 0.231
mcpkanbo_ready0.47 / 0.620.78 / 0.924.57 / 4.993
mcpkanbo_columns0.10 / 0.210.08 / 0.100.09 / 0.111
mcpkanbo_card_list0.87 / 0.941.78 / 1.9911.0 / 11.33
mcpkanbo_card_list { waitingForPerson }0.40 / 0.440.79 / 0.822.49 / 2.903
mcpkanbo_card_list { column: in_progress }0.57 / 0.610.98 / 1.512.56 / 2.703
mcpkanbo_card_list { detail: full }0.83 / 0.891.81 / 1.9110.8 / 11.43
mcpkanbo_card_get0.59 / 0.700.54 / 0.590.59 / 0.746
mcpkanbo_card_get { include: all }0.78 / 1.110.73 / 0.770.83 / 1.079
mcpkanbo_card_pull_requests0.35 / 0.390.34 / 0.420.35 / 0.404
mcpkanbo_sprints0.18 / 0.200.23 / 0.250.74 / 1.363
mcpkanbo_card_create0.91 / 1.120.99 / 1.442.03 / 2.6915
mcpkanbo_card_move1.14 / 1.221.12 / 1.261.21 / 1.3819
serveGET /issues2.25 / 2.5612.6 / 17.5122.3 / 132.22
cli (spawned)card list92.8 / 99.494.3 / 96.5106.5 / 107.4—
cli (spawned)ready91.8 / 92.092.0 / 93.497.5 / 97.8—
cli (spawned)card get 594.4 / 95.592.7 / 93.393.0 / 94.9—
cli (spawned)board93.1 / 93.6107.0 / 108.2221.2 / 232.2—

Postgres (PGlite, in process)#

surfaceoperation100 cards1,000 cardsstatements
opscreate card2.63 / 2.772.72 / 2.9110
opsmove card3.56 / 4.003.44 / 3.5313
opslist cards3.40 / 3.7721.7 / 23.82
opsready1.25 / 1.405.36 / 5.732
opsprime0.27 / 0.300.26 / 0.281
opscard get + comments1.63 / 2.111.57 / 1.865
cli (in-process)card list6.52 / 7.616.58 / 7.146
cli (in-process)card list --column in_progress5.92 / 7.586.23 / 7.766
cli (in-process)ready5.57 / 6.585.73 / 6.266
cli (in-process)prime3.89 / 4.553.74 / 4.104
cli (in-process)card get6.22 / 6.725.72 / 6.599
cli (in-process)board7.65 / 8.5227.3 / 28.66
mcpkanbo_prime0.43 / 0.690.30 / 0.341
mcpkanbo_ready1.57 / 1.791.75 / 1.823
mcpkanbo_columns0.35 / 0.470.29 / 0.341
mcpkanbo_card_list2.42 / 2.993.06 / 3.613
mcpkanbo_card_list { waitingForPerson }1.34 / 1.592.54 / 2.873
mcpkanbo_card_list { column: in_progress }1.73 / 1.832.68 / 2.813
mcpkanbo_card_list { detail: full }2.35 / 2.733.08 / 3.243
mcpkanbo_card_get2.15 / 2.522.06 / 2.686
mcpkanbo_card_get { include: all }2.92 / 3.462.87 / 3.279
mcpkanbo_card_pull_requests1.27 / 1.351.25 / 1.454
mcpkanbo_sprints0.77 / 0.930.84 / 0.913
mcpkanbo_card_create6.69 / 7.136.52 / 7.4215
mcpkanbo_card_move7.50 / 7.927.32 / 8.1017
serveGET /issues4.77 / 7.8228.6 / 30.22

Seeding (through the operations, not part of any timing): SQLite 0.2 s / 1.5 s / 20 s, PGlite 0.7 s / 6.4 s for 100 / 1,000 / 10,000 cards. PGlite at 10,000 cards was not measured again after agent efficiency (it seeds for about two minutes); its numbers before are in the section below.

Before and after agent efficiency#

The reads an agent makes most, p50 in ms. "Before" is 5e34eef; "after" is the tables above.

engineread100 cards1,000 cards10,000 cards
SQLitekanbo_card_list1.16 → 0.878.20 → 1.7885.7 → 11.0
SQLitekanbo_ready0.99 → 0.475.26 → 0.7852.3 → 4.57
SQLitekanbo_card_get0.82 → 0.593.55 → 0.5432.7 → 0.59
SQLitekanbo_sprints0.55 → 0.182.91 → 0.2326.3 → 0.74
SQLitekanbo ready (in-process)1.79 → 1.156.36 → 1.6753.6 → 6.43
SQLitekanbo card list (in-process)2.37 → 1.899.18 → 2.8192.7 → 13.6
SQLitekanbo card list (spawned)106.5 → 92.8114.3 → 94.3234.4 → 106.5
SQLitekanbo ready (spawned)99.5 → 91.8107.0 → 92.0204.4 → 97.5
PGlitekanbo_card_list4.80 → 2.4259.1 → 3.06375.0 → not measured
PGlitekanbo_ready4.55 → 1.5738.2 → 1.75300.4 → not measured
PGlitekanbo_card_get4.95 → 2.1540.6 → 2.06142.9 → not measured
PGlitekanbo_sprints2.61 → 0.7736.7 → 0.84191.2 → not measured
PGlitekanbo ready (in-process)9.16 → 5.5750.6 → 5.73342.5 → not measured
PGlitekanbo card list (in-process)9.40 → 6.5297.2 → 6.58410.6 → not measured

What changed:

  • kanbo_card_list, kanbo card list and kanbo board --column ask the database for the cards a question picks — columns, waiting for a person, parent, running, text, changed since, labels, priority — and for one page of them with the total, in one statement (BoardStore.issues.listPage, count(*) over ()). They answer 50 cards unless told otherwise.
  • kanbo_ready and kanbo ready are the same statement with the ready rule (To Do, waiting for no one, no running run); 10 cards unless told otherwise. The running cards are one in (select …) set, not a lookup per card: on PGlite a correlated not exists took kanbo_ready at 1,000 cards to 15 ms, the set 2 ms.
  • kanbo_card_get reads the sub-cards by parent instead of reading the whole board, and brings the latest comments with it.
  • kanbo_sprints counts cards per sprint and column in one grouped statement (BoardStore.issues.countByMilestone) instead of reading every card.
  • Still whole-board: kanbo board without --column, GET /issues and the ops "list cards" row (a host's full read) — they show every card by design.

Statements per read#

Counted by an opt-in drizzle logger on the board handle (src/perf/query-counter.ts), on for the tests and the bench only; a board in use runs with drizzle's no-op logger. src/perf/query-count.test.ts runs every read below on boards of 10 and 50 cards and fails when a count differs between them — a read that asks once per card (an N+1) — or changes from the numbers here.

readSQLitePostgresbefore (SQLite / Postgres)
kanbo card list684 / 6
kanbo card list with every filter795 / 7
kanbo ready684 / 6
kanbo prime352 / 4
kanbo card get (now with comments and sub-cards)684 / 6
kanbo board46same
a card with its comments (ops)55same
kanbo_card_list553 / 3
kanbo_card_list with every filter664 / 4
kanbo_ready553 / 3
kanbo_prime221 / 1
kanbo_card_get (now with comments and sub-cards)554 / 4
kanbo_card_get with every part88new
kanbo_sprints33new in the guard; now counts in SQL
GET /issues22same
GET /issues/:id/comments33same

"Before" is the 0.3.0 agent-efficiency build (3e69998). Since the real-agent fixes, a list page costs two more — which of its cards a person returned, and the last comment of the waiting and returned ones, two statements for the whole page — kanbo_ready and kanbo ready two more for the returned cards they name first, and kanbo_prime one. At 1,000 cards on SQLite (p50): kanbo_card_list 1.78 → 2.49 ms, kanbo_ready 0.78 → 1.75 ms, kanbo_prime 0.08 → 0.89 ms.

A command on Postgres runs two more than on SQLite: the check that the database holds a board this build can write to. A filter adds no statement — it is part of the one that reads the cards; naming a parent card adds the one that finds it. kanbo_card_get costs one statement per part it brings (sub-cards, comments, runs, history, pull requests) and saves the agent a call per part. No read asks once per card. Writes are constant too: creating a card is 10 statements, moving one 13–15 (field history, the change counter, the column's entry rules).

MCP response size#

Characters of each tool's text answer; tokens estimated as characters / 4. The same on both engines.

tool100 cards1,000 cards10,000 cards (SQLite)
kanbo_prime1,992 ch ≈ 498 tok1,992 ch ≈ 498 tok1,992 ch ≈ 498 tok
kanbo_columns1,197 ch ≈ 299 tok1,197 ch ≈ 299 tok1,197 ch ≈ 299 tok
kanbo_ready1,198 ch ≈ 300 tok1,156 ch ≈ 289 tok1,158 ch ≈ 290 tok
kanbo_card_list7,117 ch ≈ 1,779 tok7,105 ch ≈ 1,776 tok7,101 ch ≈ 1,775 tok
kanbo_card_list waitingForPerson: true1,811 ch ≈ 453 tok9,036 ch ≈ 2,259 tok9,042 ch ≈ 2,261 tok
kanbo_card_list column: "in_progress"4,612 ch ≈ 1,153 tok11,933 ch ≈ 2,983 tok12,061 ch ≈ 3,015 tok
kanbo_card_list detail: "full"29,310 ch ≈ 7,328 tok29,284 ch ≈ 7,321 tok29,274 ch ≈ 7,319 tok
kanbo_card_get1,413 ch ≈ 353 tok1,415 ch ≈ 354 tok1,418 ch ≈ 355 tok
kanbo_card_get with every part2,116 ch ≈ 529 tok2,118 ch ≈ 530 tok2,122 ch ≈ 531 tok
kanbo_card_pull_requests, kanbo_sprints2 ch ([])2 ch2 ch

Before and after, default arguments:

tool100 cards1,000 cards
kanbo_card_list20,520 → 1,779 tok178,117 → 1,776 tok
kanbo_ready5,239 → 300 tok49,543 → 289 tok
kanbo_card_get161 → 353 tok161 → 354 tok

Since the real-agent fixes (1,000 cards, SQLite): kanbo_card_list 7,799 ch ≈ 1,950 tok (a waiting card now carries its last comment, up to 200 characters), waitingForPerson: true 15,165 ch ≈ 3,791 tok (every row a waiting card with its comment), kanbo_ready 1,219 ch ≈ 305 tok, kanbo_prime 1,960 ch ≈ 490 tok (no returned card on the seeded board). The default list stays under 3,000 tokens.

A list answer no longer grows with the board: one page (50 cards, 10 for kanbo_ready) of compact cards, about 140 characters each, and the total. A page of cards being worked on is the largest (a status line and a run on each, ~240 characters). kanbo_card_get grew because it now carries the card's latest comments (two on these boards) and its sub-cards — what an agent used to read with more calls. detail: "full" prints what a list printed before, one page at a time.

Indexes#

Query plans (EXPLAIN QUERY PLAN on SQLite, EXPLAIN ANALYZE on PGlite) at 10,000 cards:

  • The card list (where workspace_id = ? order by "order", created_at desc) — the base of list, ready, board and GET /issues — finds the workspace's rows by an existing index and sorts them. An index on (workspace_id, "order", created_at desc) removes the sort: SQLite 15.6 → 9.6 ms, Postgres execution 19.3 → 4.6 ms (its sort spilled 4.4 MB to disk). End to end the read barely moves — 136 → 125 ms on PGlite, where reading 10,000 wide rows back, not finding them, is the cost; through drizzle on SQLite the same read is 40 ms, of which the sort is the 6 ms saved.
  • Run facts (issue_runs by issue_id), comments (issue_comments by issue_id), and card lookups by key or number already use indexes.

No index was added: the one candidate is not a clear win at 10,000 cards, and a schema change is not worth under 10%. Worth revisiting on a real Postgres server with a small work_mem, where the spilled sort costs more.

Known limits#

  • A page still counts every picked card. count(*) over () makes the database walk every card a question picks before it cuts the page, so an unfiltered kanbo_card_list is 11 ms at 10,000 cards on SQLite, not the 0.8 ms of a filtered one.
  • Some reads are whole-board by design: kanbo board without --column, GET /issues and a host's own full list — 70–120 ms at 10,000 cards on SQLite, 300–450 ms on PGlite (measured before agent efficiency).
  • Over HTTP, filters run in the MCP process. A host's server answers /issues with at most one column and one parent; kanbo_card_list through createHttpTransport reads that and applies the rest itself, so the answer matches the board file's but the server still sends every card of the column.
  • Text search folds ASCII case only on SQLite (like); Postgres folds every letter (ilike).
  • A spawned kanbo costs ~90–100 ms before it does anything (Node start-up and loading the CLI); an agent calling the MCP server pays that once.
  • PGlite is not a networked server. On Supabase each statement adds a round trip (often 1–30 ms), so the statement counts above matter more than these times.

Running the bench#

sh
npm run build                                    # the spawned-CLI timings run dist/cli.cjs
npm run bench                                    # 100, 1,000, 10,000 cards on both engines
npm run bench -- --sizes 1000 --engines sqlite   # one size, one engine
npm run bench -- --iterations 5 --no-spawn       # fewer samples, no spawned CLI
npm run bench -- --out bench.md                  # also write the report to a file

Options: --sizes, --engines (sqlite,postgres), --iterations (20), --spawn-iterations (5), --payload-sizes (sizes to report MCP payloads for: 100,1000), --no-spawn, --out. The full run takes several minutes, most of it seeding 10,000 cards into PGlite; one size and one engine at a time keeps each run short.

The Bench workflow runs it at 1,000 cards weekly and on demand (Actions → Bench → Run workflow), and attaches the report as the bench artifact and the job summary. It never runs on a push.

Real agents#

What real coding agents do with a board, measured with evals/agent-eval.mjs on 2026-09-28: each run is a fresh git project (a tiny JavaScript package and a seeded board), kanbo connect for the variant, and one sentence of task given to the agent headless. The run is scored from the board afterwards and from the agent's transcript. Run by hand before a release; it costs money and is never in CI.

  • Agents: Claude Code 2.1.283 with --model sonnet; Codex CLI 0.153.0 with its default model (codex exec).
  • Variants: full — kanbo connect <agent> --project (the instruction block and the MCP server); mcp — MCP only; instructions — the instruction block only, the agent using kanbo in its shell. Codex was run on full only.
  • Builds: 3e69998 (after agent efficiency) and, for the three scenarios where it matters, 4c3e532 (before it).
  • Runs: 3 per scenario, variant, agent and build — 69 runs: 45 Claude Code on 3e69998, 9 Claude Code on 4c3e532, 15 Codex. Claude Code reported $9.34 in all (31 agent-minutes); Codex 18 agent-minutes, no cost reported.
  • Kanbo calls are MCP kanbo_* tool calls plus shell commands running kanbo, failed ones included (in brackets: how many failed, over the three runs). Tokens are everything the agent reported for the run — input, output and cache reads — so they are dominated by the agent's own system prompt and tools. Raw results: evals/results/2026-09-28.json.
buildagentvariantscenarioall rules keptmedian kanbo calls (failed)median tokensmedian output tokensmedian time (s)median cost ($)
3e69998Claude Codefulltake-next3/39 (1)512,2052,756370.21
3e69998Claude Codefullwhats-waiting1/34 (1)166,935648100.09
3e69998Claude Codefullplan-big3/38 (1)275,5572,115400.15
3e69998Claude Codefullplan-small3/33 (0)171,2131,198190.11
3e69998Claude Codefullreturned3/38 (0)557,6403,754540.23
3e69998Claude Codemcptake-next3/310 (4)438,1642,933330.19
3e69998Claude Codemcpwhats-waiting1/34 (2)167,837812110.10
3e69998Claude Codemcpplan-big3/36 (0)170,3961,696220.11
3e69998Claude Codemcpplan-small3/34 (0)166,8341,385240.10
3e69998Claude Codemcpreturned3/38 (1)529,5663,939530.22
3e69998Claude Codeinstructionstake-next3/310 (1)672,3372,982470.26
3e69998Claude Codeinstructionswhats-waiting0/34 (0)211,248841210.12
3e69998Claude Codeinstructionsplan-big3/310 (0)388,1683,516430.20
3e69998Claude Codeinstructionsplan-small3/33 (0)212,8271,595250.13
3e69998Claude Codeinstructionsreturned3/39 (0)932,5415,295660.34
3e69998Codexfulltake-next3/316 (3)355,0891,76388—
3e69998Codexfullwhats-waiting0/34 (0)108,77836022—
3e69998Codexfullplan-big3/317 (3)270,4103,715128—
3e69998Codexfullplan-small3/314 (3)187,6121,47769—
3e69998Codexfullreturned3/316 (3)340,3541,59272—
4c3e532Claude Codefulltake-next3/39 (0)386,2522,421280.17
4c3e532Claude Codefullwhats-waiting3/32 (0)128,947483140.08
4c3e532Claude Codefullreturned3/38 (2)645,4685,180540.27

Rules. On 3e69998 every rule check was kept in every run, on both agents and every variant — 264 of 264 — except one: "at most two kanbo calls" in whats-waiting (2 of 12 runs). Out of 12 runs per scenario: the agent took the To Do card and not the Backlog one, moved it to In Progress, wrote at least two status lines, commented the result, left the card in In Review or waiting for a person, and never tried kanbo approve (12/12 on take-next); it split the three-part card into sub-cards of it and created no top-level card (12/12), and left the typo card whole (12/12); it read the person's comment on the returned card, fixed what the comment asked, added the test and handed the card back (12/12); it named both cards waiting for the person and changed nothing (12/12).

Before and after agent efficiency. On this nine-card board the calls did not go down. Before, kanbo_card_list answered every card with everything, so "what's waiting for me" was kanbo_prime + one list (2 calls, 3/3 runs). After, the agent filters ({ waitingForPerson: true }) and gets compact rows — then opens each waiting card with kanbo_card_get to see its comments (3–6 calls in 10 of 12 runs). The compact answer is what keeps a 1,000-card board readable (see MCP response size); on a small board the follow-up calls cost more than the rows saved.

Where kanbo confused the agents on 3e69998 (transcript excerpts; what was changed for each is in after the fixes):

  • kanbo_card_comment takes content, while kanbo_status_line and kanbo_wait_approval take text. Claude Code sent text in 6 runs (4 on 3e69998, 2 on 4c3e532), got Invalid arguments … expected string, received undefined at content, and sent it again: kanbo_card_comment {"card":"TST-002","text":"Added slugify(text) …"} [failed].
  • A card is answered as {"id":"TST-005", …} but kanbo_card_get wants card: kanbo_card_get {"id":"TST-005"} [failed], twice in one run, then ToolSearch select:mcp__kanbo__kanbo_card_get and the call again. Claude Code defers MCP tools behind its tool search; an agent that calls a tool before loading its schema guesses the argument names from the answers it has seen.
  • kanbo run finish --state is finished, failed or stopped; agents write completed or succeeded first — 11 of the 12 Codex runs that started a run, and at least 2 of the 8 Claude Code runs that did: kanbo run finish b116e026-… --state completed → Unknown run state "completed".
  • "Continue the card that was returned to you" has no direct question. The returned card sits in In Progress, so kanbo ready does not show it, and agents search — one run: kanbo_card_list {"column":"in_review"}, {"hasActiveRun":true}, {"column":"in_progress"}, {"waitingForPerson":false} before kanbo_card_get (4 list calls); two of three Codex runs first opened the To Do card ready offered (kanbo card get TST-003 …). The status line it finds reads returned by you: … — said to the person, read by the agent.
  • Claude Code does not know its own session id. The prime text asks for claude:<session id>, and agents invent one: "session":"claude:sonnet-5-session", claude:current, --session "claude:$(echo $CLAUDE_SESSION_ID)" (a variable name the agent guessed), or put it in a status line (Started via claude:session, …).
  • With the shell, agents read kanbo capabilities to learn the commands: 13 of 15 Claude Code runs with instructions only and 12 of 15 Codex runs; none with MCP, whose tool list already says it.

Headless Codex needs default_tools_approval_mode = "approve" on the kanbo MCP server: codex exec never asks, so without it every kanbo_* tool is refused (MCP tool call requires approval, but approval policy is never). With it, Codex still made 190 of its 199 kanbo calls through the shell — the instruction block and kanbo prime name commands.

After the fixes#

What changed for each confusion above (CHANGELOG, "where real agents got confused"): tool arguments are also accepted under the names agents reached for (text for a comment, id for a card, content for a status line, to for a column), and a missing or wrong one is answered with one sentence and a call that works; completed, succeeded and the like are read as finished, and starting a run prints the call that finishes it; a card a person sent back is returned, listed first by kanbo_ready / kanbo ready / kanbo prime with the person's comment, and its status line reads returned by a person: …; a waiting card in a list carries its last comment (and, on the command line, its status line); kanbo run start fills in the Claude Code or Codex session from the environment; kanbo prime writes each command out with its arguments; kanbo connect codex writes the approval line.

Re-run on 2026-09-28 with Claude Code 2.1.283 --model sonnet, variants full and instructions, all five scenarios, 3 runs each: build 379f6b5 (the fixes), and for instructions / whats-waiting 8dc8d12 (the command-line list also prints a waiting card's status line — the first re-run showed agents still opening each waiting card to read it). Raw results: evals/results/2026-09-28-t35.json and evals/results/2026-09-28-t35-waiting.json. Before is 3e69998, the same groups. Capabilities counts runs that read kanbo capabilities (or the kanbo://capabilities resource).

agentvariantscenarioall rules keptmedian kanbo callsfailed kanbo calls (3 runs)median tokensruns reading capabilitiesmedian cost ($)
Claude Codefulltake-next3/3 → 3/39 → 91 → 1512,205 → 390,0880 → 00.21 → 0.17
Claude Codefullwhats-waiting1/3 → 3/34 → 21 → 0166,935 → 130,9550 → 00.09 → 0.08
Claude Codefullplan-big3/3 → 3/38 → 101 → 0275,557 → 247,8330 → 00.15 → 0.15
Claude Codefullplan-small3/3 → 3/33 → 50 → 0171,213 → 197,8700 → 00.11 → 0.11
Claude Codefullreturned3/3 → 3/38 → 70 → 0557,640 → 529,4230 → 00.23 → 0.23
Claude Codeinstructionstake-next3/3 → 3/310 → 61 → 0672,337 → 395,1813 → 00.26 → 0.16
Claude Codeinstructionswhats-waiting0/3 → 2/34 → 20 → 0211,248 → 124,4632 → 00.12 → 0.07
Claude Codeinstructionsplan-big3/3 → 3/310 → 70 → 0388,168 → 292,1112 → 10.20 → 0.13
Claude Codeinstructionsplan-small3/3 → 3/33 → 20 → 0212,827 → 157,1623 → 00.13 → 0.09
Claude Codeinstructionsreturned3/3 → 3/39 → 70 → 0932,541 → 453,0043 → 00.34 → 0.20

Over the 30 runs: all rules kept 25 → 29; kanbo calls 202 → 177; failed kanbo calls 4 → 1; runs reading kanbo capabilities 13 → 1. Every rule check other than "at most two kanbo calls" was kept in every run, before and after. Claude Code reported $4.57 for the re-runs (33 runs, the 3 replaced whats-waiting runs included).

  • Arguments. No run sent text to kanbo_card_comment or id to a card tool and failed: the one failed call left is kanbo_card_move {"id":"TST-002","to":"in_progress"}, answered kanbo_card_move needs `column` (the column slug, e.g. in_progress). Example: … and called right the next time; to is accepted since ba4e70f.
  • Finish states. 5 run finish calls (was 6); none wrote completed or succeeded (was 2), and none failed.
  • Sessions. No agent passed --session or session (was 3 of 6 runs that started one, with invented ids); the run started over MCP recorded claude:32432f5a-…, the session id of that very Claude Code transcript.
  • Returned card. returned took 7 calls on the median in both variants (was 8 and 9), with no list searching: the card is first in kanbo_ready / kanbo prime.
  • What is waiting. With MCP, kanbo_prime + one kanbo_card_list { waitingForPerson: true } in all 3 runs. From the shell, kanbo prime + kanbo card list --waiting in 2 of 3; the third also asked kanbo card list --returned ("waiting for me"), a third call the scenario counts against it.

Remaining. plan-big and plan-small in the full variant took more calls than before (10 and 5 median): in plan-big every run then moved the three new sub-cards one by one (kanbo_card_move ×3, none before), and in plan-small two runs wrote a closing status line and a comment. Both are the agent's own choices, allowed by the rules; neither is a failed call. One instructions run still read kanbo capabilities before splitting a card.

Codex was not re-run: its account hit its usage limit on the first call ("You've hit your usage limit"), so the 10 planned runs produced nothing and were discarded. Its numbers above are 3e69998's.