Verdict: An autonomous AI agent task board is the single highest-leverage workflow upgrade you can make in 2026. Instead of dragging cards on a to-do list and doing the work yourself, you drop one idea onto a shared board, a project-manager agent decomposes it into tasks, you approve the plan once, and a team of specialist agents builds and ships the work in the background. Hermes Agent's Kanban system (shipped in v0.12.0, May 2026) is the only open-source option that combines a durable SQLite-backed board, named agent profiles with persistent memory, dependency tracking, crash recovery, and a human-in-the-loop approval gate in one package.
Last verified: 2026-07-31 · Primary tool: Hermes Agent (open source, NousResearch) · Latest tested version: 0.19.x · Pricing/limits change often — last checked 2026-07-31. TL;DR: (1) Install Hermes Agent, run
hermes kanban init+hermes gateway start. (2) Create specialist profiles (researcher, writer, engineer, reviewer). (3) Drop an idea as a triage task; a specifier agent expands it into a plan. (4) Approve the plan — the dispatcher fans it out to worker agents. (5) Agents build, self-check, and ship to a gallery you can preview live.
What is an autonomous AI agent task board?
An autonomous AI agent task board is a Kanban board where the workers are AI agents, not humans. Each card is a row in a database. Each handoff between agents is a logged event. A dispatcher loop watches the board, claims ready tasks, and spawns the assigned agent profile as a full operating-system process. You contribute the idea and the approval; the agents contribute the execution.
The difference between this and a normal to-do list is who does the work. On a conventional board, you write the ticket, you drag the card, you build the thing. On an agent board, you write one sentence, an orchestrator agent writes the tickets for you, and specialist agents build each one. The board is not a passive list — it is a self-driving pipeline.
Hermes Agent introduced its Kanban system in v0.12.0 on May 3, 2026 (official announcement, NousResearch; Digg coverage). The board state lives in a single SQLite database at ~/.hermes/kanban.db, shared between the CLI, the dashboard, and the dispatcher. Everything visible in the web UI is also available from the command line.
Why a board beats a chat window for AI work
Most people still work with AI by going back and forth in a chat window. That works for a single question. It breaks down the moment you want to build anything with more than two steps:
- You lose context. A long chat thread compresses or forgets earlier instructions. A board stores every task, comment, and handoff as a durable row that any agent can re-read on spawn.
- You cannot parallelize. One chat thread is one stream of work. A board lets a researcher, a designer, and a coder work at the same time against separate tasks.
- You have no audit trail. When something goes sideways in chat, there is no replay. On a board, every state change is timestamped and tied to an agent ID — you can see exactly which agent moved what card and when.
- You cannot recover from crashes. If a chat session dies mid-task, the work is gone. On a Hermes Kanban board, the dispatcher detects the dead process, reclaims the task, and re-queues it. After three consecutive failures the task auto-locks for manual review — preventing an infinite retry loop.
Q: Is Hermes Kanban free? A: Yes. Hermes Agent is open source under the Hermes license from NousResearch. The Kanban feature ships with the core agent — no paid add-on, no per-seat fee. You supply your own model API keys (or run a local model), which is the only recurring cost.
The 5-stage pipeline: idea to shipped output
The cleanest mental model is a five-floor elevator. Your idea rides it from top to bottom. You step in exactly once — at the approval gate. Here is how each stage maps to a Hermes Kanban task state.
Stage 1 — Triage: capture the idea (status: triage)
You drop a single sentence onto the board. Example: "Build a landing page for my consulting business that shows the value of AI automation." At this point the idea is rough — it has no spec, no assignee, no task breakdown. It sits in the triage column waiting to be shaped.
hermes kanban create "Build a landing page for my consulting business" --triage
The --triage flag lands the card in the triage column instead of todo, signalling that it needs a specifier agent to expand it before work can begin.
Stage 2 — Specify: work out what it is (status: todo)
A specialist specifier agent (configured under auxiliary.triage_specifier in config.yaml) reads the one-liner, infers the intent, and expands it into a full plan: a title, a body with acceptance criteria, a list of sub-tasks, and suggested assignees for each. Run it manually or let the dispatcher sweep the triage column on its tick:
hermes kanban specify t_abcd # expand one task
hermes kanban specify --all # sweep the whole triage column
The specifier is an auxiliary LLM call, not a full worker — it is fast and cheap. Its output is a set of concrete todo tasks that are ready to promote.
Stage 3 — Approve: the human-in-the-loop gate (status: ready)
This is the one place you step in. The specifier's plan is visible on the board (or in your chat via a gateway notification). You approve it, reject it, or edit it before approval. In production autonomous setups the approval is often scoped to a quick review of the plan title and the list of sub-task assignees — you are not reviewing code, you are confirming the plan makes sense.
Once you approve, the dispatcher promotes the parent task and its children to ready. From here on, you are optional.
Stage 4 — Build: agents do the work (status: running)
The dispatcher loop (default 60-second tick, runs inside the gateway) claims ready tasks atomically and spawns the assigned profile as a full OS process. Each worker:
- Calls
kanban_show()to read its task body, parent handoffs, and the comment thread. - Does the work inside its own isolated workspace (
scratchby default — a fresh tmp dir; or adirshared workspace; or a gitworktree). - Calls
kanban_heartbeat()on long operations so the dispatcher knows it is alive. - On completion, calls
kanban_complete(summary=..., metadata=...)with a structured handoff (changed files, test counts, decisions) that downstream agents read via their ownkanban_show. - If blocked (missing credential, needs human decision), calls
kanban_block(reason=...)— the task surfaces on the board, you unblock it with a comment, and the dispatcher respawns the worker with the full thread.
Tasks with parent-child dependencies do not promote to ready until every parent reaches done — so you can model an entire build pipeline as a dependency graph and the dispatcher walks it in order.
Q: What happens when an AI agent crashes mid-task?
A: The dispatcher detects the dead PID on its next tick, closes the run row with outcome crashed, clears the task's current-run pointer, and re-queues the task as ready for the next tick. After three consecutive failures the task auto-locks pending manual intervention — this is the circuit breaker that prevents an infinite retry loop from burning API credits.
Stage 5 — Ship: review the gallery (status: done)
Completed tasks land in done with their artifacts declared via kanban_complete(artifacts=[...]). Declared artifacts are copied to durable storage before a scratch workspace is cleaned up. You can preview the output live in the dashboard, link it from other posts, or hand it off to a reviewer agent for a quality gate before promotion.
The "self-checker" pattern the video crowd loves maps directly to a reviewer profile: create a done-state review task that depends on the build task, assigned to a reviewer agent that runs the same checks a human reviewer would (tests pass, lint clean, output renders). Only when the reviewer calls kanban_complete does the pipeline advance.
Step-by-step: set up your first autonomous board
Step 1 — Install Hermes Agent and start the gateway
# Install (pick one)
pip install hermes-agent
# or
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
# Verify
hermes --version # needs v0.12.0+ for Kanban; v0.19.x is current as of 2026-07-31
# Initialize the board (creates ~/.hermes/kanban.db)
hermes kanban init
# Start the gateway — hosts the dispatcher loop and the dashboard
hermes gateway start
The dashboard runs at localhost:9119 by default and shows the full board with per-profile lanes, task drawers, and run history.
Step 2 — Create specialist agent profiles
Profiles are named agents with their own system prompt, tools, and persistent memory. Define them in ~/.hermes/config.yaml or via the profile directory. A minimal team for content/website work:
| Profile | Role | Recommended model tier |
|---|---|---|
researcher |
Keyword research, fact-checking, source gathering | Mid (cheap, many calls) |
writer |
Draft articles from research briefs | Strong (quality-critical) |
engineer |
Build pages, tools, integrations | Strong + coding-tuned |
reviewer |
QA gate: lint, tests, render check, accuracy | Mid (cheaper judge is fine) |
orchestrator |
Decomposes goals into child tasks, routes work | Strong (reasoning-heavy) |
The orchestrator uses kanban_create to fan out into child tasks — one per specialist — and kanban_link to wire parent-child dependencies so children wait until parents finish.
Step 3 — Drop an idea and let the specifier expand it
hermes kanban create "Build a blog for my consulting business that shows the power of AI automation" --triage
# Expand the triage card into a real plan
hermes kanban specify --all
The specifier returns a plan: research keywords → design the site → build on a modern stack → add internal links → set up tracking, with each step assigned to the right profile.
Step 4 — Review and approve the plan
Open the dashboard at localhost:9119 (or run hermes kanban list) and review the specifier's output. Edit titles or reassign profiles if needed, then promote the tasks to ready. If you prefer the CLI:
hermes kanban unblock t_abcd # promotes to ready
Step 5 — Watch the agents build, then preview the output
hermes kanban watch # live activity stream
hermes kanban list # current board state
hermes kanban stats # throughput, completion rate
The dispatcher picks up ready tasks, spawns workers, and you watch the board fill in. Workers hand off via kanban_comment and structured metadata, so the reviewer agent already knows what the engineer changed before it starts.
How Hermes Kanban compares to a plain delegate-task call
Both delegate_task and Kanban exist in Hermes. They serve different purposes and coexist:
| Feature | delegate_task |
Hermes Kanban |
|---|---|---|
| Best for | Single quick subtask, result goes back into parent context | Multi-step projects, team coordination, anything that survives a restart |
| Visibility | Chat-based, ephemeral | Visual board + full durable history |
| Human in the loop | Not supported | Comment / unblock / approve at any point |
| Resumability | None | Block → unblock → re-run; crash → reclaim |
| Coordination | Hierarchical (caller → callee) | Peer — any profile reads/writes any task |
| Audit trail | Lost on context compression | Durable rows in SQLite, forever |
Rule of thumb: if you need a fast in-context answer, use delegate_task. If the work crosses agent boundaries, might need human input, or should be discoverable next week, use Kanban. A kanban worker can call delegate_task internally during its run — they compose. For more on how these layers fit together, see our AI agent loops engineering guide and the multi-agent team orchestration stack walkthrough.
What this means for you
If you are a solo builder or a small team, an autonomous board is the difference between doing every task and approving every task. The work you used to grind through — research, drafting, scaffolding, QA — happens while you sleep, and you review the plan and the finished artifact instead of the intermediate steps.
Three things make the biggest difference in practice:
- Put the human approval at the right floor. Approving the plan (Stage 3) is cheap insurance with huge leverage — it catches wrong-intent before any agent burns tokens. Approving the output (Stage 5) is where you protect quality. Skip either and the system drifts.
- Use persistent memory + the comment thread. Because every worker reads the full comment thread on spawn, your corrections compound — you say "use dark mode" once in a comment and every future worker on that task sees it. This is the "second brain" effect that makes agents feel context-aware instead of amnesiac. See how this fits a broader AI agent operating system setup.
- Let the cheaper agent do the building; let the stronger agent do the judging. A midpoint model can draft and scaffold; a frontier model reviewing its work catches more errors than the same frontier model drafting from scratch — at a fraction of the cost. Our AI agent loop cost analysis walks through the math.
FAQ
Q: Do I need to know how to code to run an autonomous agent board?
A: No. Hermes Kanban is driven by typing a sentence and pressing enter. The hermes kanban create and hermes kanban specify commands accept plain-language task descriptions. The dispatcher and the agent profiles handle the rest. If you can write a to-do item, you can run this board.
Q: Can more than one AI agent work at the same time on the same board?
A: Yes. The dispatcher claims ready tasks atomically (SQLite CAS), so multiple agent profiles — researcher, writer, engineer, reviewer — can pick up different tasks in parallel without stepping on each other. Each worker sees only its board's tasks via the HERMES_KANBAN_BOARD environment variable, keeping multi-project work isolated.
Q: What happens if my AI agent gets stuck or needs a decision from me?
A: The worker calls kanban_block(reason=...) with a one-line description of the decision it needs. The task surfaces on the board as blocked, and if you have a gateway channel wired up (Telegram, Discord), you get a notification. You unblock it with a comment containing the answer, and the dispatcher respawns the worker with the full thread in context.
Q: How much does it cost to run an autonomous AI agent board? A: Hermes Agent itself is free and open source. Your only recurring cost is model API access. A practical setup is a mid-tier model for research and review (many small calls) and a stronger model for writing and engineering (fewer, higher-stakes calls). Routed through a free or low-cost provider, a single content pipeline can run for under a dollar per finished article. Limits and pricing change — re-check monthly.
Q: Is Hermes Kanban better than using a regular to-do app with an AI chatbot? A: For anything multi-step, yes. A regular to-do app stores your tasks but does not execute them. An AI chatbot executes but has no memory of last week's tasks and cannot parallelize. Hermes Kanban is the layer that combines durable task storage, named agents with persistent memory, dependency tracking, and a dispatcher that actually moves the work forward. It is the difference between a list and a factory.
Q: Can I run this entirely locally without sending data to a cloud model? A: Yes. Hermes Agent supports local model runtimes (Ollama, llama.cpp) and local tool execution. Pair it with a free local model setup and your task board, agent memory, and execution all stay on your machine. The trade-off is speed and quality versus privacy — see our local AI agent guide for the model-choice details.
Discussion
0 comments