Autonomous Kanban Agent in Hermes: Task Queues and Approval Gates for Bot SwarmsArticle · digest for October 30
Architectural isometric view of a Hermes Agent Kanban board with an approval gate and robot worker figurines moving cards.
Article3 sections≈ 5 min

Autonomous Kanban Agent in Hermes: Task Queues and Approval Gates for Bot Swarms

Scaling AI automation from a single chat assistant to a swarm of specialized agents immediately hits a coordination wall. How do you split work across five virtual engineers? How do you stop two bots from editing the same file at the same time? And most importantly, how do you keep architectural control without drowning in hundreds of log lines?

Traditional workarounds using bloated in-memory arrays or spaghetti scripts built on early multi-agent libraries fall apart fast: if one child process crashes, the whole pipeline collapses and task state vanishes.

Nous Research came up with a clever, battle-tested answer inside its agent framework: Hermes Kanban. It's a distributed, file-oriented task manager backed by a local SQLite database (~/.hermes/kanban.db). Instead of fragile subprocesses, each agent runs as an independent, isolated OS worker, passing the baton through a familiar Kanban board with explicit task statuses.

I spun up the Hermes Kanban loop, configured an orchestrator agent, and tested the Human-in-the-Loop approval gate. Let's see how the mechanism works and how it turns a chaotic bot swarm into a disciplined agile team.

Role Separation: Orchestrators and Workers

Hermes Kanban draws a crisp line between planning and execution:

  1. Orchestrator Agents: Equipped with decomposition and planning tools (kanban_create, kanban_link, kanban_prioritize). The orchestrator takes a high-level goal from a human (for instance, "Build a Go authentication microservice with JWT support, Redis caching, and tests"), breaks it into an atomic task graph, sets dependencies, and moves cards into the Ready column.
  2. Worker Agents: Specialized bots (coders, frontend builders, QA testers, doc writers). Each worker polls the board (kanban_list), grabs an available ticket into In Progress—locking out parallel edits from peers (kanban_claim)—runs the job in an isolated sandbox, and moves the card to Review.

Toolset and the Human-in-the-Loop Approval Gate

A worker agent's profile is defined by a clean JSON manifest that caps step budgets and restricts allowed tools:

{
  "profile_name": "QA-Worker-Agent",
  "model": "deepseek-ai/deepseek-v4-flash",
  "tools": [
    "kanban_list",
    "kanban_claim",
    "kanban_comment",
    "kanban_complete",
    "run_bash_command"
  ],
  "budget": {
    "max_steps_per_task": 20,
    "max_cost_usd": 2.50
  },
  "guardrails": {
    "consecutive_failure_limit": 3,
    "require_human_review_on_block": true
  }
}

At the approval gate, a lightweight Python watchdog polls the Review column and prompts a human with interactive cards before changes are merged:

import sqlite3
import os

def process_review_queue(db_path=os.path.expanduser("~/.hermes/kanban.db")):
    """Polls the Review column and requests human approval."""
    conn = sqlite3.connect(db_path)
    cursor = conn.cursor()
    cursor.execute("SELECT id, title, worker_id, artifacts_url FROM tasks WHERE status = 'Review'")
    review_tasks = cursor.fetchall()
    
    if not review_tasks:
        print("[Hermes Kanban] Задач на ревью нет. Доска чиста.")
        return
        
    for task_id, title, worker_id, artifacts in review_tasks:
        print(f"\n[Ревью тикета #{task_id}] {title}")
        print(f"Исполнитель: {worker_id} | Артефакты: {artifacts}")
        decision = input("Одобрить перенос в Done? (y/n/rework): ").strip().lower()
        
        if decision == "y":
            cursor.execute("UPDATE tasks SET status = 'Done' WHERE id = ?", (task_id,))
            print(f"Тикет #{task_id} закрыт и слит в основную ветку.")
        elif decision == "rework":
            comment = input("Укажите причину доработки: ")
            cursor.execute("UPDATE tasks SET status = 'In Progress', comments = comments || ? WHERE id = ?", (f"\nРевью: {comment}", task_id))
            print(f"Тикет #{task_id} возвращен воркеру на исправление.")
            
    conn.commit()
    conn.close()

if __name__ == "__main__":
    process_review_queue()

Why a Kanban Board Suits an Agent Swarm

Applying classic Kanban to autonomous agents solves three fundamental problems at once:

  • Fault tolerance: If a worker hangs or times out, the database automatically releases the lock on the ticket and drops it back to Ready, letting another agent pick it up without restarting the system.
  • Visual auditing: A human can open the local board UI anytime to see exactly where a project stands, which worker owns a ticket, and what notes the model left behind.
  • Preventing infinite loops: If an agent fails to pass tests three times in a row, the card moves to Blocked and the system pings a human via sound alert or messenger webhook.
  • Syncing with team trackers: When needed, Hermes Kanban mirrors column states into Jira, Linear, or GitHub Projects, keeping the entire product team in the loop.

Hermes Kanban pairs AI speed with the clarity and reliability of classic project management—turning chaotic bot experiments into a predictable production pipeline.

Want a deep diveVotes help us choose what to break down in detail. This material has 0 votes.
Sources · 1