Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    KanbanAI flow — service-delivery-manager

    1

    Run a Kanban board of AI role agents: replenishment, WIP limits, pull-based dispatch and flow cadences on the ex-workflow engine.

    Free

    Security scanned
    KanbanAI flow — service-delivery-manager

    KanbanAI flow — service-delivery-manager

    Example session with this skill installed

    Run a Kanban board on these requests: SEARCH (search box, standard), EXPORT (CSV export, fixed-date 2026-11-01), HOTFIX (login crash, expedite), DOCS (API notes, intangible). Replenish what fits, pull within the WIP limits, and run the cadences when they are due.

    • Read your context and instructions
    • Compiled the kanbanai flow

    Summary

    The board below is the engine's own command loop as the skill drives it (the sequence the bundled test runs), narrated by the Service Delivery Manager persona. Every line comes from a wf command's JSON output.

    Init and options

    wf init kanban --config .workflow/config.json      → columns options → ready (WIP 4, commitment) → dev (WIP 3) → review (WIP 2) → done
    wf add SEARCH.json --by service-request-manager      → item.added (standard)
    wf add EXPORT.json --by service-request-manager      → item.added (fixed-date, deadline 2026-11-01)
    wf add HOTFIX.json --by service-request-manager      → item.added (expedite)
    wf add DOCS.json   --by service-request-manager      → item.added (intangible)
    wf next                                              → reason: no-candidates (nothing past the commitment point yet)
    

    Replenishment

    Dan (SDM): Ready has 4 free slots. Prae, what do we pull?
    Prae (SRM): HOTFIX first (expedite), EXPORT (due 1 Nov), SEARCH, then DOCS — all four fit.
    — you confirm —

    wf ceremony replenishment rep.json --by service-request-manager   → cadence.replenishment { column: "ready", items: [HOTFIX(expedite), EXPORT(fixed-date), SEARCH(standard), DOCS(intangible)] }
    

    Flow

    wf next --max 2   → briefs: HOTFIX@dev (expedite first), EXPORT@dev; skipped: SEARCH (wip: stage "dev" is at its WIP limit of 3 with the bypass used), DOCS (wip)
    wf complete HOTFIX h1.json --tokens-in 61200 --tokens-out 0 --duration-ms 41000 --model haiku   → HOTFIX → review
    wf next --max 2   → briefs: HOTFIX@review (fresh worker), SEARCH@dev
    wf complete HOTFIX h2.json …                         → item.completed, HOTFIX → done
    

    Dan: Round 2. dev: EXPORT, SEARCH (2/3); review: 0/2; done: HOTFIX. DOCS waits in ready. No blockers.

    Cadences (when wf status says they are due)

    wf ceremony operations-review ops.json --by service-delivery-manager   → cadence.operations-review { blockers: [], aging: [] }
    wf ceremony service-delivery-review sdr.json --by service-delivery-manager   → cadence.service-delivery-review (WIP and policies unchanged; 1 lesson read from handoffs)
    wf ceremony risk-review risk.json --by service-delivery-manager   → cadence.risk-review { fixedDateAtRisk: [], staleBlockers: [] }
    wf metrics   → leadTimeP50, leadTimeP85, cycleTimeMsByColumn, throughput, wipByColumn, flowEfficiency, agingWipMs, sleCompliance, blockerTimeMs
    

    Next steps

    • Keep pulling: wf next whenever a column frees a slot; wf unblock <id> --note when a blocker's follow-up lands.
    • Strategy review with Prae's proposal when cadencesDue lists it; apply class-of-service changes only with your yes.
    • Stop when options and the board are empty; wf metrics is the closing report.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    KanbanAI flow runs a Kanban board of AI role agents inside your coding agent (Claude Code, Codex CLI, Cursor or any host that can run a prompt and node). The orchestrator is the service-delivery-manager skill; the service-request-manager and worker role skills are nested under roles/, so one install gives you a working team.

    What it does

    • Seeds options from a service goal: the Service Request Manager proposes requests with acceptance criteria, a class of service (standard, expedite, fixed-date with a deadline, intangible) and priority; you edit, the engine stores them.
    • Replenishes within WIP limits: the SRM proposes which options to pull into the commitment column; you confirm; the engine refuses a pull past the WIP limit or a card without acceptance criteria.
    • Pulls and dispatches cards to workers only when a downstream column has a free slot; expedite cards jump the queue, fixed-date cards go by deadline, aging keeps standard and intangible cards from starving.
    • Records handoffs with the evidence each column's exit policy asks for; a review always goes to a fresh worker.
    • Runs the cadences the engine says are due: operations review (blockers, aging work), service delivery review (WIP, policies, SLEs, lessons), risk review, delivery planning, strategy review (classes of service) — every change to the board needs your yes.
    • Reports flow metrics from the engine: lead time (p50/p85), cycle time per column, throughput, WIP, flow efficiency, aging, cumulative flow, SLE compliance, blocker time.

    How it works

    The engine is scripts/wf.js, a bundled build of the ex-workflow state machine (Kanban columns, WIP rules, classes of service, cadences, flow metrics; published on npm as ex-workflow, MIT). All state lives in .workflow/ in your project; nothing leaves your machine. The skill is prose: it tells the host which wf command to run, how to build each worker prompt, and what to say to you.

    What's inside

    SKILL.md (the orchestrator), policy.json (default five-column board, service levels, cadence schedule, personas, host model map), reference/ (every command with its JSON shapes, cadence narration, the worker contract, team voice), roles/service-request-manager/, roles/worker/, scripts/wf.js + scripts/package.json.

    Known limitations

    Kanban has no engine retrospective: lessons raised in handoffs are adopted at the service delivery review into team memory files. Budgets are sized from the host's token counter; a host that reports no usage runs with estimates. This orchestrator has been exercised through the engine's full command loop (replenish, pull, deliver, review, every cadence) but not yet on a multi-day run with real workers; the Scrum sibling listing has.

    Support

    Message the creator on Agensi; updates ship as new listing versions.

    No engine retrospective exists for Kanban; lessons are adopted at the service delivery review into team files. Budgets are sized from the host's token counter; a host that reports no usage runs with estimates. Exercised through the engine's full command loop and every cadence, not yet on a multi-day run with real workers.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Free forever

    No account required to browse

    Trust & safety

    Security scan

    Security scan passed 18 days ago

    • Free with an Agensi account

    Requires

    Node.js 18 or later

    Permissions

    Terminal / Shell
    Read Files
    Write Files

    File Scopes

    .workflow/**

    The bundled scripts/wf.js is the MIT ex-workflow engine; it reads and writes only .workflow/ under the project root. No network.

    Listed24 days ago
    Updated15 days ago

    What's inside

    Frequently Asked Questions

    A prompted manager pushes work, forgets limits and lets a worker review its own card. Here the bundled ex-workflow engine (scripts/wf.js) owns the board: a card enters the commitment column only through replenishment within the WIP limit, is pulled downstream only when a slot is free, leaves a column only with the evidence its exit policy names, and is reviewed by a fresh worker. The orchestrator runs wf commands and narrates what they return; it cannot push.

    SKILL.md (the service-delivery-manager orchestrator), policy.json (default five-column board, service levels, cadence schedule, personas, host model map), reference/ (commands.md with every wf command and the Kanban cadence inputs and payloads, cadences.md narration, handoff.md worker contract, team.md), roles/service-request-manager/ and roles/worker/ (a SKILL.md plus the engine role manifest each), and scripts/wf.js with scripts/package.json (the bundled MIT engine). 12 files, no network, all state under .workflow/.

    Any host that follows the SKILL.md standard, can run a prompt and has Node.js 18+ on PATH. Tested on Claude Code, where workers are dispatched as subagents; a host without subagents plays each role inline with the same prompt. policy.json maps small/medium/large tiers to host model names (the defaults never use the largest models); a non-Claude host maps them to its own.

    By the engine, not the prose. wip-respected refuses a replenishment past the commitment column's limit and the planner skips a pull when the next column is full (reported as skipped: wip). Classes of service order the pull: question items, then expedite (one active at a time, with a WIP bypass), fixed-date by deadline, standard by priority with aging, intangible last but never starved. Cadences are engine ceremonies with their own events; wf status says which are due (everyTurns in policy.json), and changes to WIP, policies, SLEs or classes go through service-delivery-review and strategy-review only with your yes.

    The command loop (init, options, replenishment, pull, deliver, review, every cadence, metrics) runs end to end in the package's test suite against the bundled engine; a multi-day run with real workers has not been done yet (the Scrum sibling listing has three such sprints). The engine is the npm package ex-workflow (MIT); each listing version bundles one engine version, buyers get new versions as updates, and your .workflow/state.json loads unchanged across versions. For problems or questions, message the creator on Agensi.

    New in Agents & Orchestration