Noureddine RAMDI / Agent Kanban: orchestrating AI coding agents with cryptographic identities

Created Mon, 04 May 2026 10:23:02 +0000 Modified Sat, 23 May 2026 20:41:27 +0000
977 Words
github-stars typescript ai-agent multi-agent cryptography cli react

saltbo/agent-kanban

Agent Kanban tackles a core challenge in AI development: how to orchestrate multiple AI coding agents as autonomous team members while maintaining trust and auditability. It treats each AI agent as a first-class entity with a cryptographic identity that persists across git commits, pull requests, and task claims. This approach enables a secure, verifiable workflow for autonomous agents collaborating on codebases.

What agent kanban is and how it works

At its core, Agent Kanban is a multi-agent orchestration platform built with TypeScript. It uses a leader-worker architecture to coordinate AI coding agents, each assigned specific roles and skills. The leader agent decomposes high-level goals into tasks, assigns them to worker agents through a daemon process, and reviews their pull requests.

Agents are equipped with cryptographic identities based on Ed25519 keys. These identities persist across git operations, allowing task claims, commits, and PR signatures to be cryptographically verified. This design choice adds a trust layer uncommon in typical AI agent setups, where identities are often ephemeral or opaque.

The platform supports multiple AI runtimes through the Agent Communication Protocol (ACP). Currently supported runtimes include Claude Code, Codex CLI, Gemini CLI, GitHub Copilot CLI, and Hermes. This abstraction allows Agent Kanban to orchestrate a heterogeneous team of AI agents seamlessly.

Under the hood, the backend API uses the Hono framework, with SQLite/D1 for storage. The frontend is a React web UI that receives real-time updates via Server-Sent Events (SSE), providing a responsive user experience. There is also a kubectl-style CLI tool called ak that interacts with the daemon and agents.

One of the key technical innovations is atomic task claiming using D1 batch operations. This ensures that tasks are claimed in a concurrency-safe manner, preventing race conditions in multi-agent environments. The system also implements role-based routing for agent self-organization, enabling autonomous delegation and dynamic reassignment of tasks.

why the cryptographic identity and architecture matter

The standout feature of Agent Kanban is the use of Ed25519 cryptographic identities for AI agents. Each agent holds a persistent keypair that signs git commits, pull requests, and task claims. This produces an auditable chain of trust linking code changes back to specific agents.

In practice, this means you can verify which agent performed which task, and that the task claims were not spoofed. This is a significant step toward accountability in AI-driven software development, where multiple autonomous agents collaborate asynchronously.

The leader-worker pattern implemented here is also noteworthy. The leader decomposes complex goals into smaller, assignable tasks, then delegates these to worker agents. The worker agents operate in isolated worktrees set up by the daemon, each running their assigned tasks independently. This separation of concerns simplifies concurrency management and scaling.

Supporting multiple agent runtimes via the ACP is a pragmatic design choice. It avoids locking the platform into a single AI model or vendor and allows developers to run whichever compatible agent suits their needs or preferences.

However, this architecture also introduces complexity. The system depends on external runtimes and requires setting up an API key and daemon to manage tasks. The cryptographic identity management adds an extra layer to the workflow that developers need to understand and maintain.

The codebase itself is TypeScript-based throughout, which favors maintainability and developer experience. The use of SQLite/D1 as a storage backend suggests the project prioritizes simplicity and atomicity for task state management over distributed database complexity.

quick start to running agent kanban

The project provides a clear quickstart path:

  1. Ensure you have GitHub CLI (gh) authenticated with gh auth login.
  2. Have at least one AI agent runtime installed, such as Claude Code or GitHub Copilot CLI.
  3. Install the agent-kanban CLI tool:
volta install agent-kanban   # or: npm install -g agent-kanban

ak config set --api-url https://agent-kanban.dev --api-key ak_xxxxx
  1. Start the daemon, which polls for tasks and manages worker agents:
ak start

You can monitor daemon status and logs with:

ak status
ak logs -f
ak stop
  1. Install skills globally for your agents:
npx skills add saltbo/agent-kanban --skill ak-plan --skill ak-task --agent claude-code -gy
  1. Create a leader agent identity:
ak identity create --username alex --name "Alex Chen"

Once set up, you can use commands like /ak-plan v1.0 to analyze codebases and create task boards, or /ak-task fix the login redirect bug to assign and track individual tasks.

verdict: who should consider agent kanban

Agent Kanban is relevant for researchers and developers building complex AI-assisted coding workflows who want a verifiable trust layer between agents. Its cryptographic identity system and atomic task management provide a foundation for accountable multi-agent collaboration.

That said, the system assumes familiarity with multiple AI runtimes, CLI tooling, and cryptographic key management. It is not a turnkey solution but a flexible platform for those willing to invest in integrating and orchestrating AI agents in their development pipelines.

If you are exploring autonomous AI coding agents beyond simple script automation and need auditability, Agent Kanban offers a unique and practical approach worth understanding and experimenting with. However, expect a learning curve and infrastructure setup overhead.

Overall, it is a solid, technically thoughtful platform that pushes the boundary on what trust and identity mean in AI-driven software development.

→ GitHub Repo: saltbo/agent-kanban ⭐ 241 · TypeScript