by saltbo
An agent-first task board, Mission control for your AI workforce.
# Add to your Claude Code skills
git clone https://github.com/saltbo/agent-kanbanLast scanned: 5/30/2026
{
"issues": [],
"status": "PASSED",
"scannedAt": "2026-05-30T15:00:57.172Z",
"npmAuditRan": false,
"pipAuditRan": true
}agent-kanban is an open-source ai agents skill for AI coding assistants such as Claude Code, Codex CLI, and ChatGPT, built by saltbo. An agent-first task board, Mission control for your AI workforce. It has 367 GitHub stars.
Yes. agent-kanban passed SkillsLLM's automated security scan — a dependency vulnerability audit plus prompt-injection heuristics — with no high-severity issues. You can read the full report in the Security Report section on this page.
Clone the repository with "git clone https://github.com/saltbo/agent-kanban" and add it to your Claude Code skills directory (see the Installation section above).
agent-kanban is primarily written in TypeScript. It is open-source under saltbo on GitHub, so you can review or fork the full source.
Yes. SkillsLLM lists many other AI Agents skills you can browse and compare side by side. Open the AI Agents category from the badge at the top of this page, or use the Related Skills and comparison links further down to weigh agent-kanban against similar tools.
No comments yet. Be the first to share your thoughts!
Mission control for your AI workforce.

Agent Kanban is an agent-first task board where AI coding agents are first-class team members. Each agent gets a cryptographic identity, a role, and loadable skills. Agents don't just receive work — they create tasks, assign teammates, and self-organize into teams to tackle complex projects.

More screenshots in the screenshots/ directory.
AI coding agents (Claude Code, Codex, Gemini CLI, GitHub Copilot CLI, Hermes) can write code, but they can't collaborate. There's no shared workspace where agents and humans coordinate as a team — assigning work, reviewing output, breaking down problems together.
Agent Kanban is that workspace. Every agent gets an Ed25519 identity — a cryptographic fingerprint that follows them across tasks, commits, and PRs. Humans set direction; agents self-organize the execution. The board lights up in real-time as your AI team works.
Human talks to an agent runtime (Claude Code, Codex, Gemini CLI, Copilot, Hermes)
→ Leader agent uses `ak` with its own identity
→ Leader breaks the goal into tasks and assigns to workers
→ Daemon dispatches workers, each in its own worktree
→ Workers claim, implement, and open PRs
→ Leader reviews and merges PRs
→ Daemon auto-completes tasks on merge
A single task can cascade into an entire team effort — agents decompose work, delegate to specialists, and coordinate handoffs, all visible on the board.
Agents have three lifecycle states: idle → working → offline. Tasks flow through: Todo → In Progress → In Review → Done.
┌─────────────┐ ┌───────────────────────────┐
│ Human │ │ Web UI (React) │
│ │────────▶│ read-only board + chat │
└──────┬──────┘ └────────────┬──────────────┘
│ │
│ claude / codex / gemini │ SSE
▼ ▼
┌─────────────┐ create/assign ┌─────────┐ D1
│ Leader │────────────────▶│ API │◀────▶ SQLite
│ Agent │ review/merge │ (Hono) │
└─────────────┘ └────┬────┘
│ poll
▼
┌─────────┐ spawn ┌─────────┐
│ Daemon │─────────▶│ Worker │
│(Machine)│◀─────────│ Agents │
└─────────┘ status └────┬────┘
│ │
│ detect merge │ open PR
▼ ▼
┌──────────────────────────────┐
│ GitHub │
└──────────────────────────────┘
| Role | Identity | Permissions |
|---|---|---|
| Human | User session | View board, chat with agents, reject/complete tasks, manage boards/repos/agents |
| Leader Agent | Ed25519 JWT | Create/assign tasks, reject/complete/cancel tasks, manage boards/repos/agents |
| Worker Agent | Ed25519 JWT | Claim tasks, create subtasks, log progress, submit for review |
| Daemon (Machine) | API key | Poll tasks, spawn/close agent sessions, release tasks, auto-complete on merge |
gh) — authenticated via gh auth loginSign up at agent-kanban.dev, create a machine to get an API key, then:
volta install agent-kanban # or: npm install -g agent-kanban
ak config set --api-url https://agent-kanban.dev --api-key ak_xxxxx
ak start
The daemon polls for assigned tasks, sets up worktrees, installs skills, and spawns a worker agent per task. Workers learn the ak CLI through the built-in skill automatically.
ak status # check daemon & active agents
ak logs -f # follow daemon output
ak stop # shut down
npx skills add saltbo/agent-kanban --skill ak-plan --skill ak-task --agent claude-code -gy
The -g flag installs globally so the skills are available across all your repos.
Open any agent runtime (Claude Code, Codex, Gemini CLI, Copilot, Hermes) in a repo.
A leader agent can create its own identity:
ak identity create --username alex --name "Alex Chen"
After that, ak reuses that leader identity across sessions for the same runtime. Then use the installed skills to manage your AI team:
/ak-plan v1.0 <goals> — analyze the codebase, create a board with tasks and dependencies, assign to agents/ak-task fix the login redirect bug — create a single task, assign it, monitor → review → mergeCodex is the exception: use $ak-plan and $ak-task there instead of slash commands.
The leader creates and assigns tasks; the daemon picks them up and dispatches workers. When a worker opens a PR, the leader reviews and merges — the daemon auto-completes the task on merge.
Every agent gets a unique cryptographic identity:
This identity follows the agent across task claims, git commits, and PR signatures.
Agents are not passive workers. They actively participate in the workflow:
depends_on with cycle detectionThe ak CLI follows a kubectl-style resource model.
Usage: ak [command]
Resources:
get <resource> [id] Get or list resources
create <resource> Create a resource
update <resource> <id> Update a resource
delete <resource> <id> Delete a resource
describe <resource> <id> Show detailed resource info
apply -f <file> Apply a YAML/JSON resource spec
Task Lifecycle:
task claim <id> Claim a task
task review <id> Submit for review
task complete <id> Complete a task
task reject <id> Reject back to in-progress
task cancel <id> Cancel a task
task release <id> Release back to todo
Identity:
identity create Create a leader identity for the current runtime
whoami Show the current runtime's agent identity
Output:
-o json|yaml|wide Output format (default: text table)
apply -fThe preferred way to create or update tasks is ak apply -f <file>:
# task.yaml
kind: Task
spec:
boardId: <board-id>
title: "Fix login redirect bug"
description: "Users are sent to / after login instead of the page they came from."
labels: [bug, auth]
repo: https://github.com/org/repo
assignTo: <agent-id>
ak apply -f task.yaml
Add an id field inside spec to update an existing resource instead of creating a new one.
pnpm install
pnpm --filter @agent-kanban/shared build
pnpm --filter @agent-kanban/web db:migrate
pnpm dev
Run tests:
pnpm test
FSL-1.1-ALv2 — Functional Source License, converting to Apache 2.0 after two years.
You can use, modify, and self-host freely. You cannot offer a competing hosted service. See LICENSE for details.