Show HN: Kanban CLI (A local-first, agent-first task manager for the terminal) (codeberg.org)
Ever since agents have become increasingly common in development, I've been scratching my head as to how to control their randomness. Recently, I decided to emulate an issue-tracking and project-management tool for agent-driven workflows.
Kanban is a Rust-based coordination layer designed to provide a feature-rich terminal interface and enforce rigorous workflows. It aims to be versatile and extendable, made to be tailored to any preferred flow. It comes with full git integration and guardrails such that only what truly benefits a project can go through.
The workflow boils down to 4 steps:
1. The model reads the skill to contextualize the requirements
2. It authenticates and receives a strict, schema-validated JSON payload outlining exact files, context, and acceptance criteria
3. Implementation is performed within an automatically isolated Git worktree and branch. The tool tracks progress (e.g., verifying all files were edited) before the task is submitted for review
4. A reviewer (preferably a human) evaluates the submission and manually transitions the task to "Done," which triggers the final merge and cleans up the task-specific environment.
The tool significantly decreases the agent development time, while increasing the human planning phase.
There is more to it than I can cover here, so I'd be happy to answer any questions about the architecture, the workflow, or the insights I gained while using it. For more information, I recommend skimming the README, which acts as an index to all documentation files.
12 comments
[ 2.7 ms ] story [ 38.1 ms ] threadHow does your tool compare? What makes it better? I'm rooting for competition in this area.
MY KANBAN CLI IS:
A project management system to plan, estimate, track sprints, measure velocity, assign roles, and give agents structured tasks with acceptance criteria.
CLINE KANBAN IS:
An agent execution platform to run multiple AI agents in parallel on isolated worktrees, review diffs in a web UI, and auto-commit/PR their output.
SIMILARITIES:
- Local
- Git integration with worktree support
- Agent integration with parallel execution
- Task and dependency tracking
DIFFERENCES:
- Language: Rust 2021 vs TypeScript/Node.js
- Interface: Terminal CLI (JSON output) vs Browser web app (React SPA)
- Task Creation: Human-focused vs Agent-focused
- Agent Control: Agent runs the tool as a CLI utility vs Platform spawns and manages the agent as a child process
- Core Engine: Sprints, story points, velocity, and role-personas vs MCP server management, web diff viewers, and auto-PR toggles
- Lifecycle: 8-state validation engine vs 4-column drag-and-drop layout
- Concurrency: File locking (fd-lock) for safe multi-agent CLI access vs Git worktree isolation for massive parallelism (hundreds of agents)
- Output Target: JSON by default (agents consume it) vs Web UI by default (humans consume it)
- Self-Management: Recalibration engine (auto-heal data, reorder tasks, rebalance sprints, archive) vs Not present
- People Registry: Humans tracked separately from agents (people.json) vs Not present
- Storage: JSON files in .kanban/ (atomic writes, two-tier locking) vs Runtime state streams + config files (no persistent task database)
- Statistics: Cycle time, lead time, revisions, blocks, effort ratio vs None
- Coordination: Shared with teammates via git vs Independent instance
There are many more differences between the two, which brings me to my first point. All in all, I see my Kanban as being a much more structured, human-centric, and controlled environment, since it's a complete management system rather than just an execution layer.
You can practically plan the whole project using my tool, before any implementation even starts. That means complete project structure (via files_to_modify), acceptance criterias (+ context), commit messages, branch names, version bump (handled automatically by the tool as tasks are completed) and so on. It's a full project trace, which uses the full potential of a human + agent development workflow.